#include "my_define.h"
#include "stm32f1xx_it.h"
#include "usart.h"


/**
  * @brief This function handles Non maskable interrupt.
  */
void NMI_Handler(void)
{
  /* USER CODE BEGIN NonMaskableInt_IRQn 0 */

  /* USER CODE END NonMaskableInt_IRQn 0 */
  /* USER CODE BEGIN NonMaskableInt_IRQn 1 */

  /* USER CODE END NonMaskableInt_IRQn 1 */
}

/**
  * @brief This function handles Hard fault interrupt.
  */
void HardFault_Handler(void)
{
  /* USER CODE BEGIN HardFault_IRQn 0 */

  /* USER CODE END HardFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_HardFault_IRQn 0 */
    /* USER CODE END W1_HardFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Memory management fault.
  */
void MemManage_Handler(void)
{
  /* USER CODE BEGIN MemoryManagement_IRQn 0 */

  /* USER CODE END MemoryManagement_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */
    /* USER CODE END W1_MemoryManagement_IRQn 0 */
  }
}

/**
  * @brief This function handles Prefetch fault, memory access fault.
  */
void BusFault_Handler(void)
{
  /* USER CODE BEGIN BusFault_IRQn 0 */

  /* USER CODE END BusFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_BusFault_IRQn 0 */
    /* USER CODE END W1_BusFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Undefined instruction or illegal state.
  */
void UsageFault_Handler(void)
{
  /* USER CODE BEGIN UsageFault_IRQn 0 */

  /* USER CODE END UsageFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_UsageFault_IRQn 0 */
    /* USER CODE END W1_UsageFault_IRQn 0 */
  }
}

/**
  * @brief This function handles System service call via SWI instruction.
  */
void SVC_Handler(void)
{
  /* USER CODE BEGIN SVCall_IRQn 0 */

  /* USER CODE END SVCall_IRQn 0 */
  /* USER CODE BEGIN SVCall_IRQn 1 */

  /* USER CODE END SVCall_IRQn 1 */
}

/**
  * @brief This function handles Debug monitor.
  */
void DebugMon_Handler(void)
{
  /* USER CODE BEGIN DebugMonitor_IRQn 0 */

  /* USER CODE END DebugMonitor_IRQn 0 */
  /* USER CODE BEGIN DebugMonitor_IRQn 1 */

  /* USER CODE END DebugMonitor_IRQn 1 */
}

/**
  * @brief This function handles Pendable request for system service.
  */
void PendSV_Handler(void)
{
  /* USER CODE BEGIN PendSV_IRQn 0 */

  /* USER CODE END PendSV_IRQn 0 */
  /* USER CODE BEGIN PendSV_IRQn 1 */

  /* USER CODE END PendSV_IRQn 1 */
}

/**
  * @brief This function handles System tick timer.
  */
void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */

  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */

  /* USER CODE END SysTick_IRQn 1 */
}

void USART1_IRQHandler(void)
{
	u16 first;
	u16 last;
	if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)){
		__HAL_UART_CLEAR_IDLEFLAG(&huart1);
		first=mUart[0].rx_queue.dma_addr;							//第一个字节地址
		last=UART_RX_QBUFLEN-__HAL_DMA_GET_COUNTER(&hdma_usart1_rx);//最后一个字节地址
		mUart[0].rx_queue.dma_addr=last;							//更新DMA写到的地址
		uart_rx_write_to_queue(0,first,last);						//写入队列
	}
}
void USART2_IRQHandler(void)
{
	u16 first;
	u16 last;
	if(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE)){
		__HAL_UART_CLEAR_IDLEFLAG(&huart2);
		first=mUart[1].rx_queue.dma_addr;							//第一个字节地址
		last=UART_RX_QBUFLEN-__HAL_DMA_GET_COUNTER(&hdma_usart2_rx);//最后一个字节地址
		mUart[1].rx_queue.dma_addr=last;							//更新DMA写到的地址
		uart_rx_write_to_queue(1,first,last);						//写入队列
	}
}
void USART3_IRQHandler(void)
{
	u16 first;
	u16 last;
	if(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_IDLE)){
		__HAL_UART_CLEAR_IDLEFLAG(&huart3);
		first=mUart[2].rx_queue.dma_addr;							//第一个字节地址
		last=UART_RX_QBUFLEN-__HAL_DMA_GET_COUNTER(&hdma_usart3_rx);//最后一个字节地址
		mUart[2].rx_queue.dma_addr=last;							//更新DMA写到的地址
		uart_rx_write_to_queue(2,first,last);						//写入队列
	}
}
void UART4_IRQHandler(void)
{
	u16 first;
	u16 last;
	if(__HAL_UART_GET_FLAG(&huart4,UART_FLAG_IDLE)){
		__HAL_UART_CLEAR_IDLEFLAG(&huart4);
		first=mUart[3].rx_queue.dma_addr;							//第一个字节地址
		last=UART_RX_QBUFLEN-__HAL_DMA_GET_COUNTER(&hdma_uart4_rx);	//最后一个字节地址
		mUart[3].rx_queue.dma_addr=last;							//更新DMA写到的地址
		uart_rx_write_to_queue(3,first,last);						//写入队列
	}
}
void UART5_IRQHandler(void)
{
	if(__HAL_UART_GET_FLAG(&huart5,UART_FLAG_RXNE)){
		__HAL_UART_CLEAR_FLAG(&huart5,UART_FLAG_RXNE);
		uart_get_rx_data_it(huart5.Instance->DR);
	}
}

//dma发送完成不代表串口发送完成，若要操作串口，需要改用串口tc中断
void DMA1_Channel2_IRQHandler(void)
{
	if(__HAL_DMA_GET_FLAG(&hdma_usart3_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_usart3_tx))){
		__HAL_DMA_CLEAR_FLAG(&hdma_usart3_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_usart3_tx));
		mUart[2].tx_queue.flags.busy=0;
		HAL_DMA_Abort(&hdma_usart3_tx);						//dma使能不会自动关闭。由于使用了hal库的发送，有互斥锁，需要调用hal库的中止来解锁
		__HAL_DMA_ENABLE_IT(&hdma_usart3_tx, DMA_IT_TC);	//但是解锁函数回同时关闭中断，所以还需要重新打开中断
	}
}
void DMA1_Channel4_IRQHandler(void)
{
	if(__HAL_DMA_GET_FLAG(&hdma_usart1_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_usart1_tx))){
		__HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_usart1_tx));
		mUart[0].tx_queue.flags.busy=0;
		HAL_DMA_Abort(&hdma_usart1_tx);						//dma使能不会自动关闭。由于使用了hal库的发送，有互斥锁，需要调用hal库的中止来解锁
		__HAL_DMA_ENABLE_IT(&hdma_usart1_tx, DMA_IT_TC);	//但是解锁函数回同时关闭中断，所以还需要重新打开中断
	}
}
void DMA1_Channel7_IRQHandler(void)
{
	if(__HAL_DMA_GET_FLAG(&hdma_usart2_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_usart2_tx))){
		__HAL_DMA_CLEAR_FLAG(&hdma_usart2_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_usart2_tx));
		mUart[1].tx_queue.flags.busy=0;
		HAL_DMA_Abort(&hdma_usart2_tx);						//dma使能不会自动关闭。由于使用了hal库的发送，有互斥锁，需要调用hal库的中止来解锁
		__HAL_DMA_ENABLE_IT(&hdma_usart2_tx, DMA_IT_TC);	//但是解锁函数回同时关闭中断，所以还需要重新打开中断
	}
}
void DMA2_Channel4_5_IRQHandler(void)
{
	if(__HAL_DMA_GET_FLAG(&hdma_uart4_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_uart4_tx))){
		__HAL_DMA_CLEAR_FLAG(&hdma_uart4_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_uart4_tx));
		mUart[3].tx_queue.flags.busy=0;
		HAL_DMA_Abort(&hdma_uart4_tx);						//dma使能不会自动关闭。由于使用了hal库的发送，有互斥锁，需要调用hal库的中止来解锁
		__HAL_DMA_ENABLE_IT(&hdma_uart4_tx, DMA_IT_TC);	//但是解锁函数回同时关闭中断，所以还需要重新打开中断
	}
}


